#include<algorithm>

template<typename Object>
class Vector
{
  public:
  explicit Vector(int iniSize=0) : theSize(iniSize),
				   theCapacity(iniSize + SPARE_CAPACITY)
  {objects = new Object[ theCapzcity ];}
  //允许用户指定Vector的初始大小并默认为0,同时初始化使其容量比大小稍大

  Vector(const Vector&rhs) : theSize{ rhs.theSize},
			     theCapacity{rhs.theCapacity},objects{nullptr}
  {
    objects = new Object[ theCapacity ];
    for( int k=0;k<theSize;++k )
      objects[k]=rhs.objects[k];
  }
  //创建一个新的Vector,并由operator实现使用

  Vector&operator=(const Vector&rhs)
  {
    Vector copy=rhs;
    std::swap(*this,copy);
    return *this;
  }

  ~Vector()
  {delete []objects;]

  Vector( Vector && rhs) : theSize{ rhs.theSize},
			   theCapacity{rhs.theCapacity},objects{rhs.objects}
  {
    rhs.objects=nullptr;
    rhs.theSize=0;
    rhs.theCapacity=0;
  }

  Vector & operator=(Vector &&rhs)
  {
    std::swap(theSize,rhs.theSize);
    std::swap(theCapacity,rhs.theCapacity);
    std::swap(objects,rhs.objects);

    return *this;
  }

  void resize( int newSize )
  {
    if( newSize > theCapacity)
      reserve(newSize*2);
    theSize = newSize;
  }
  //调整大小且如果需要扩展容量则将其设定至两倍以妨频繁更改扩展

  void reserve( int newCapacity)
  {
    if( newCapacity <theSize)
      return;

    Object *NewArray = new Object[ newCapacity ];
    for( int k=0; k<theSize; ++k )
      newArray[k]=std::move( objects[k] );

    theCapacity = newCapacity;
    std::swap(objects,newArray);
    delete [] newArray;
  }
  //执行扩展容量操作,分配新数组并回收旧数组

  Object & operator[](int index )
  {return objects[index];}
  const Object & operator[](int index)const
  {return objects[index];}

  bool empty() const
  {return size()==0;}
  int size()const
  {return theSize;}
  int capacity()const
  {return theCapacity;}

  void push_back(const Object&x)
  {
    if(theSize == theCapacity)
      reserve(2*theCapacity+1);
    objects[theSize++]=x;
  }

  void push_back(Object&&x)
  {
    if(theSize==theCapacity)
      reserve(2*theCapacity+1);
    objects[theSize++]=std::move(x);
  }

  void pop_back()
  {
    --theSize;
  }

  const Object & back()const
  {
    return objects[ theSize-1 ];
  }

  typedef Object * iterator;
  typedef const Object * const_iterator;

  iterator begin()
  {return &objects[0];}
  const_iterator begin()const
  {return &objects[0];}

  iterator end()
  {return &objects[size()];}
  const_iterator end()const
  {return &objects[size()];}

  static const int SPARE_CAPACITY=16;

  private:
  int theSize;
  int theCapacity;
  Object * objects;
  //将Vector的大小,容量和原始数组存储数据成员
};

